<?php

require_once 'BancoDeDados.php';
require_once 'Localizacao.php';
require_once 'HistoricoMovimentacao.php';
require_once 'Aquisicao.php';
require_once 'Classe.php';
require_once 'Material.php';
require_once 'Emprego.php';
require_once 'Origem.php';
require_once 'Estilo.php';
require_once 'Colecao.php';
require_once 'Titulo.php';
require_once 'Epoca.php';
require_once 'EspacoCultural.php';
require_once 'FatoHistorico.php';
require_once 'Fabricante.php';
require_once 'Personagem.php';
require_once 'Imagem.php';
require_once 'Assunto.php';
require_once 'Intervencao.php';
require_once 'Autor.php';
require_once 'Tecnica.php';
require_once 'Unidade.php';

/**
 * Objeto, a alma do SisPEC - 'Tá grande pra caraca
 */
class Objeto {

    private $cod_interno;
    private $cod_registro;
    private $numero_serie;
    private $marca;
    private $modelo;
    private $copia;
    private $bibliografia;
    private $etiqueta;
    private $classe;
    private $materiais;
    private $empregos;
    private $origem;
    private $fatos;
    private $fabricantes;
    private $aquisicao;
    private $personagens;
    private $imagens;
    private $estilo;
    private $assuntos;
    private $intervencoes;
    private $autores;
    private $historicos_movimentacao;
    private $localizacao;
    private $colecao;
    private $tecnicas;
    private $titulo;
    private $epoca;
    private $espaco_cultural;
    private $estado_objeto;
    private $unidades;

    function __construct(&$cod_registro, &$numero_serie, &$marca, &$modelo, &$copia, &$bibliografia, &$etiqueta, &$classe, &$espaco_cultural) {
        $this->cod_registro = &$cod_registro;
        $this->numero_serie = &$numero_serie;
        $this->marca = &$marca;
        $this->modelo = &$modelo;
        $this->copia = &$copia;
        $this->bibliografia = &$bibliografia;
        $this->etiqueta = &$etiqueta;
        $this->classe = &$classe;
        $this->espaco_cultural = &$espaco_cultural;
    }

    public function &getCod_interno() {
        return $this->cod_interno;
    }

    public function setCod_interno(&$cod_interno) {
        $this->cod_interno = &$cod_interno;
    }

    public function &getCod_registro() {
        return $this->cod_registro;
    }

    public function setCod_registro(&$cod_registro) {
        $this->cod_registro = &$cod_registro;
    }

    public function &getNumero_serie() {
        return $this->numero_serie;
    }

    public function setNumero_serie(&$numero_serie) {
        $this->numero_serie = &$numero_serie;
    }

    public function &getMarca() {
        return $this->marca;
    }

    public function setMarca(&$marca) {
        $this->marca = &$marca;
    }

    public function &getModelo() {
        return $this->modelo;
    }

    public function setModelo(&$modelo) {
        $this->modelo = &$modelo;
    }

    public function &getCopia() {
        return $this->copia;
    }

    public function setCopia(&$copia) {
        $this->copia = &$copia;
    }

    public function &getBibliografia() {
        return $this->bibliografia;
    }

    public function setBibliografia(&$bibliografia) {
        $this->bibliografia = &$bibliografia;
    }

    public function &getEtiqueta() {
        return $this->etiqueta;
    }

    public function setEtiqueta(&$etiqueta) {
        $this->etiqueta = &$etiqueta;
    }

    /**
     *
     * @return Classe
     */
    public function &getClasse() {
        return $this->classe;
    }

    public function setClasse(Classe &$classe) {
        $this->classe = &$classe;
    }

    public function &getMateriais() {
        return $this->materiais;
    }

    public function setMateriais(&$materiais) {
        $this->materiais = &$materiais;
    }

    public function addMaterial(Material &$material) {
        if ($this->materiais[$material->getCod_material()] instanceof Material) {
            throw new Exception("Material existente");
        }
        $material->setObjeto($this);
        $material->cadastrarObjeto();
        $this->materiais[$material->getCod_material()] = &$material;
    }

    public function removeMaterial($cod_material) {
        if (!($this->materiais[$cod_material] instanceof Material)) {
            throw new Exception("Material inexistente");
        }
        $this->materiais[$cod_material]->excluirObjeto();
        unset($this->materiais[$cod_material]);
    }

    public function &getEmpregos() {
        return $this->empregos;
    }

    public function setEmpregos(&$empregos) {
        $this->empregos = &$empregos;
    }

    public function addEmprego(Emprego &$emprego) {
        if ($this->empregos[$emprego->getCod_emprego()] instanceof Emprego) {
            throw new Exception("Emprego existente");
        }
        $emprego->setObjeto($this);
        $emprego->cadastrarObjeto();
        $this->empregos[$emprego->getCod_emprego()] = &$emprego;
    }

    public function removeEmprego($cod_emprego) {
        if (!($this->empregos[$cod_emprego] instanceof Emprego)) {
            throw new Exception("Emprego inexistente");
        }
        $this->empregos[$cod_emprego]->excluirObjeto();
        unset($this->empregos[$cod_emprego]);
    }

    /**
     *
     * @return Origem
     */
    public function &getOrigem() {
        return $this->origem;
    }

    public function setOrigem(Origem &$origem) {
        $this->origem = &$origem;
    }

    public function addOrigem(Origem &$origem) {
        if ($this->origem instanceof Origem) {
            throw new Exception("Origem existente");
        }
        $origem->setObjeto($this);
        $origem->cadastrarObjeto();
        $this->origem = &$origem;
    }

    public function removeOrigem() {
        if (!($this->origem instanceof Origem)) {
            throw new Exception("Origem inexistente");
        }
        $this->origem->excluirObjeto();
        unset($this->origem);
    }

    public function &getFatos() {
        return $this->fatos;
    }

    public function setFatos(&$fatos) {
        $this->fatos = &$fatos;
    }

    public function addFato(FatoHistorico &$fato) {
        if ($this->fatos[$fato->getCod_fato()] instanceof FatoHistorico) {
            throw new Exception("Fato Histórico existente");
        }
        $fato->setObjeto($this);
        $fato->cadastrarObjeto();
        $this->fatos[$fato->getCod_fato()] = &$fato;
    }

    public function removeFato($cod_fato) {
        if (!($this->fatos[$cod_fato] instanceof FatoHistorico)) {
            throw new Exception("Fato Histórico inexistente");
        }
        $this->fatos[$cod_fato]->excluirObjeto();
        unset($this->fatos[$cod_fato]);
    }

    public function &getFabricantes() {
        return $this->fabricantes;
    }

    public function setFabricantes(&$fabricantes) {
        $this->fabricantes = &$fabricantes;
    }

    public function addFabricante(Fabricante &$fabricante) {
        if ($this->fabricantes[$fabricante->getCod_fabricante()] instanceof Fabricante) {
            throw new Exception("Fabricante existente");
        }
        $fabricante->setObjeto($this);
        $fabricante->cadastrarObjeto();
        $this->fabricantes[$fabricante->getCod_fabricante()] = &$fabricante;
    }

    public function removeFabricante($cod_fabricante) {
        if (!($this->fabricantes[$cod_fabricante] instanceof Fabricante)) {
            throw new Exception("Fabricante inexistente");
        }
        $this->fabricantes[$cod_fabricante]->excluirObjeto();
        unset($this->fabricantes[$cod_fabricante]);
    }

    /**
     *
     * @return Aquisicao
     */
    public function &getAquisicao() {
        return $this->aquisicao;
    }

    public function setAquisicao(Aquisicao &$aquisicao) {
        $this->aquisicao = &$aquisicao;
    }

    public function addAquisicao(Aquisicao &$aquisicao) {
        if ($this->aquisicao instanceof Aquisicao) {
            throw new Exception("Aquisição existente");
        }
        $aquisicao->setObjeto($this);
        $aquisicao->cadastrarObjeto();
        $this->aquisicao = &$aquisicao;
    }

    public function updateAquisicao($campo_id, $campo_valor) {
        if (!($this->aquisicao instanceof Aquisicao)) {
            throw new Exception("Aquisição inexistente");
        }
        $this->aquisicao->alterarObjeto($campo_id, $campo_valor);
    }

    public function removeAquisicao() {
        if (!($this->aquisicao instanceof Aquisicao)) {
            throw new Exception("Aquisição inexistente");
        }
        $this->aquisicao->excluirObjeto();
        unset($this->aquisicao);
    }

    public function &getPersonagens() {
        return $this->personagens;
    }

    public function setPersonagens(&$personagens) {
        $this->personagens = &$personagens;
    }

    public function addPersonagem(Personagem &$personagem) {
        if ($this->personagens[$personagem->getCod_personagem()] instanceof Personagem) {
            throw new Exception("Personagem existente");
        }
        $personagem->setObjeto($this);
        $personagem->cadastrarObjeto();
        $this->personagens[$personagem->getCod_personagem()] = &$personagem;
    }

    public function removePersonagem($cod_personagem) {
        if (!($this->personagens[$cod_personagem] instanceof Personagem)) {
            throw new Exception("Personagem inexistente");
        }
        $this->personagens[$cod_personagem]->excluirObjeto();
        unset($this->personagens[$cod_personagem]);
    }

    public function &getImagens() {
        return $this->imagens;
    }

    public function setImagens(&$imagens) {
        $this->imagens = &$imagens;
    }

    public function addImagem(&$foto, &$fotografo, &$nome) {
        $imagem = new Imagem();
        $imagem->setFoto($foto);
        $imagem->setFotografo($fotografo);
        $imagem->setNome($nome);
        $imagem->setObjeto($this);
        $imagem->cadastrar();
        $this->imagens[$imagem->getCod_imagem()] = &$imagem;
    }

    public function updateImagem(&$cod_imagem, &$campo_id, &$campo_valor) {
        $imagem = $this->imagens[$cod_imagem];
        if (!($imagem instanceof Imagem)) {
            throw new Exception("Imagem inexistente");
        }
        $imagem->alterarCampo($campo_id, $campo_valor);
        $this->imagens[$cod_imagem] = &$imagem;
    }

    public function removeImagem(&$cod_imagem) {
        $imagem = &$this->imagens[$cod_imagem];
        if (!($imagem instanceof Imagem)) {
            throw new Exception("Imagem inexistente");
        }
        $imagem->excluir();
        unset($this->imagens[$cod_imagem]);
    }

    /**
     *
     * @return Estilo
     */
    public function &getEstilo() {
        return $this->estilo;
    }

    public function setEstilo(Estilo &$estilo) {
        $this->estilo = &$estilo;
    }

    public function addEstilo(Estilo &$estilo) {
        if ($this->estilo instanceof Estilo) {
            throw new Exception("Estilo existente");
        }
        $estilo->setObjeto($this);
        $estilo->cadastrarObjeto();
        $this->estilo = &$estilo;
    }

    public function removeEstilo() {
        if (!($this->estilo instanceof Estilo)) {
            throw new Exception("Estilo inexistente");
        }
        $this->estilo->excluirObjeto();
        unset($this->estilo);
    }

    public function &getAssuntos() {
        return $this->assuntos;
    }

    public function setAssuntos(&$assuntos) {
        $this->assuntos = &$assuntos;
    }

    public function addAssunto(Assunto &$assunto) {
        if ($this->assuntos[$assunto->getCod_assunto()] instanceof Assunto) {
            throw new Exception("Assunto existente");
        }
        $assunto->setObjeto($this);
        $assunto->cadastrarObjeto();
        $this->assuntos[$assunto->getCod_assunto()] = &$assunto;
    }

    public function removeAssunto($cod_assunto) {
        if (!($this->assuntos[$cod_assunto] instanceof Assunto)) {
            throw new Exception("Assunto inexistente");
        }
        $this->assuntos[$cod_assunto]->excluirObjeto();
        unset($this->assuntos[$cod_assunto]);
    }

    public function &getIntervencoes() {
        return $this->intervencoes;
    }

    public function setIntervencoes(&$intervencoes) {
        $this->intervencoes = &$intervencoes;
    }

    public function addIntervencao(&$data, &$detalhe, &$tecnico) {
        $intervencao = new Intervencao();
        $intervencao->setData($data);
        $intervencao->setDetalhe($detalhe);
        $intervencao->setTecnico($tecnico);
        $intervencao->setObjeto($this);
        $intervencao->cadastrar();
        $this->intervencoes[$intervencao->getCod_intervencao()] = &$intervencao;
    }

    public function updateIntervencao(&$cod_intervencao, &$campo_id, &$campo_valor) {
        $intervencao = $this->intervencoes[$cod_intervencao];
        if (!($intervencao instanceof Intervencao)) {
            throw new Exception("Intervenção inexistente");
        }
        $intervencao->alterarCampo($campo_id, $campo_valor);
        $this->intervencoes[$cod_intervencao] = &$intervencao;
    }

    public function removeIntervencao(&$cod_intervencao) {
        $intervencao = $this->intervencoes[$cod_intervencao];
        if (!($intervencao instanceof Intervencao)) {
            throw new Exception("Intervenção inexistente");
        }
        unset($this->intervencoes[$cod_intervencao]);
    }

    public function &getAutores() {
        return $this->autores;
    }

    public function setAutores(&$autores) {
        $this->autores = &$autores;
    }

    public function addAutor(Autor &$autor) {
        if ($this->autores[$autor->getCod_autor()] instanceof Autor) {
            throw new Exception("Autor existente");
        }
        $autor->setObjeto($this);
        $autor->cadastrarObjeto();
        $this->autores[$autor->getCod_autor()] = &$autor;
    }

    public function removeAutor($cod_autor) {
        if (!($this->autores[$cod_autor] instanceof Autor)) {
            throw new Exception("Autor inexistente");
        }
        $this->autores[$cod_autor]->excluirObjeto();
        unset($this->autores[$cod_autor]);
    }

    public function &getHistoricos_movimentacao() {
        return $this->historicos_movimentacao;
    }

    public function setHistoricos_movimentacao(&$historicos_movimentacao) {
        $this->historicos_movimentacao = &$historicos_movimentacao;
    }

    public function addHistoricoMovimentacao(&$data_retorno, &$data_saida, &$destino, &$finalidade, &$origem, &$tecnico_responsavel) {
        $historico = new HistoricoMovimentacao();
        $historico->setData_retorno($data_retorno);
        $historico->setData_saida($data_saida);
        $historico->setDestino($destino);
        $historico->setFinalidade($finalidade);
        $historico->setObjeto($this);
        $historico->setOrigem($origem);
        $historico->setTecnico_responsavel($tecnico_responsavel);
        $historico->cadastrar();
        $this->historicos_movimentacao[$historico->getCod_historico_movimentacao()] = &$historico;
    }

    public function updateHistoricoMovimentacao(&$cod_historico_movimentacao, &$campo_id, &$campo_valor) {
        $historico = $this->historicos_movimentacao[$cod_historico_movimentacao];
        if (!($historico instanceof HistoricoMovimentacao)) {
            throw new Exception("Histórico de Movimentação inexistente");
        }
        $historico->alterarCampo($campo_id, $campo_valor);
        $this->historicos_movimentacao[$cod_historico_movimentacao] = &$historico;
    }

    /**
     * @method void excluirHistoricoMovimentacao() para exclusão do recurso
     * @return void
     */
    public function removeHistoricoMovimentacao(&$cod_historico_movimentacao) {
        $historico = $this->historicos_movimentacao[$cod_historico_movimentacao];
        if (!($historico instanceof HistoricoMovimentacao)) {
            throw new Exception("Histórico de Movimentação inexistente");
        }
        $historico->exluir();
        unset($this->historicos_movimentacao[$cod_historico_movimentacao]);
    }

    /**
     *
     * @return Localizacao
     */
    public function &getLocalizacao() {
        return $this->localizacao;
    }

    public function setLocalizacao(Localizacao &$localizacao) {
        $this->localizacao = &$localizacao;
    }

    public function addLocalizacao(&$guarda, &$descricao, &$local_especifico, &$dia, &$mes, &$ano) {
        if ($this->localizacao instanceof Localizacao) {
            throw new Exception("Localização existente");
        }
        $localizacao = new Localizacao();
        $localizacao->setGuarda($guarda);
        $localizacao->setDescricao($descricao);
        $localizacao->setLocal_especifico($local_especifico);
        $localizacao->setDia($dia);
        $localizacao->setMes($mes);
        $localizacao->setAno($ano);
        $localizacao->setObjeto($this);
        $localizacao->cadastrar();
        $this->localizacao = &$localizacao;
    }

    public function updateLocalizacao(&$campo_id, &$campo_valor) {
        if (!($this->localizacao instanceof Localizacao)) {
            throw new Exception("Localização inexistente");
        }
        $localizacao = $this->localizacao;
        $localizacao->alterarCampo($campo_id, $campo_valor);
        $this->localizacao = &$localizacao;
    }

    public function removeLocalizacao() {
        if (!($this->localizacao instanceof Localizacao)) {
            throw new Exception("Localização inexistente");
        }
        $localizacao = $this->localizacao;
        $localizacao->excluir();
        unset($this->localizacao);
    }

    /**
     *
     * @return Colecao
     */
    public function &getColecao() {
        return $this->colecao;
    }

    public function setColecao(Colecao &$colecao) {
        $this->colecao = &$colecao;
    }

    public function addColecao(Colecao &$colecao) {
        if ($this->colecao instanceof Colecao) {
            throw new Exception("Coleção existente");
        }
        $colecao->setObjeto($this);
        $colecao->cadastrarObjeto();
        $this->colecao = &$colecao;
    }

    public function removeColecao() {
        if (!($this->colecao instanceof Colecao)) {
            throw new Exception("Coleção inexistente");
        }
        $this->colecao->excluirObjeto();
        unset($this->colecao);
    }

    public function &getTecnicas() {
        return $this->tecnicas;
    }

    public function setTecnicas(&$tecnicas) {
        $this->tecnicas = &$tecnicas;
    }

    public function addTecnica(Tecnica &$tecnica) {
        if ($this->tecnicas[$tecnica->getCod_tecnica()] instanceof Tecnica) {
            throw new Exception("Técnica existente");
        }
        $tecnica->setObjeto($this);
        $tecnica->cadastrarObjeto();
        $this->tecnicas[$tecnica->getCod_tecnica()] = &$tecnica;
    }

    public function removeTecnica($cod_tecnica) {
        if (!($this->tecnicas[$cod_tecnica] instanceof Tecnica)) {
            throw new Exception("Técnica inexistente");
        }
        $this->tecnicas[$cod_tecnica]->excluirObjeto();
        unset($this->tecnicas[$cod_tecnica]);
    }

    /**
     *
     * @return Titulo
     */
    public function &getTitulo() {
        return $this->titulo;
    }

    public function setTitulo(Titulo &$titulo) {
        $this->titulo = &$titulo;
    }

    public function addTitulo(Titulo &$titulo) {
        if ($this->titulo instanceof Titulo) {
            throw new Exception("Título existente");
        }
        $titulo->setObjeto($this);
        $titulo->cadastrarObjeto();
        $this->titulo = &$titulo;
    }

    public function removeTitulo() {
        if (!($this->titulo instanceof Titulo)) {
            throw new Exception("Título inexistente");
        }
        $this->titulo->excluirObjeto();
        unset($this->titulo);
    }

    /**
     *
     * @return Epoca
     */
    public function &getEpoca() {
        return $this->epoca;
    }

    public function setEpoca(Epoca &$epoca) {
        $this->epoca = &$epoca;
    }

    public function addEpoca(Epoca &$epoca) {
        if ($this->epoca instanceof Epoca) {
            throw new Exception("Época existente");
        }
        $epoca->setObjeto($this);
        $epoca->cadastrarObjeto();
        $this->epoca = &$epoca;
    }

    public function removeEpoca() {
        if (!($this->epoca instanceof Epoca)) {
            throw new Exception("Época inexistente");
        }
        $this->epoca->excluirObjeto();
        unset($this->epoca);
    }

    /**
     *
     * @return EspacoCultural
     */
    public function &getEspaco_cultural() {
        return $this->espaco_cultural;
    }

    public function setEspaco_cultural(EspacoCultural &$espaco_cultural) {
        $this->espaco_cultural = &$espaco_cultural;
    }

    /**
     *
     * @return EstadoObjeto
     */
    public function &getEstado_objeto() {
        return $this->estado_objeto;
    }

    public function setEstado_objeto(EstadoObjeto &$estado_objeto) {
        $this->estado_objeto = &$estado_objeto;
    }

    public function addEstado_objeto(EstadoObjeto &$estado_objeto) {
        if ($this->estado_objeto instanceof EstadoObjeto) {
            throw new Exception("Estado de Objeto existente");
        }
        $estado_objeto->setObjeto($this);
        $estado_objeto->cadastrarObjeto();
        $this->estado_objeto = &$estado_objeto;
    }

    public function updateEstado_objeto($campo_id, $campo_valor) {
        if (!($this->estado_objeto instanceof EstadoObjeto)) {
            throw new Exception("Estado de Objeto inexistente");
        }
        $this->estado_objeto->alterarObjeto($campo_id, $campo_valor);
    }

    public function removeEstado_objeto() {
        if (!($this->estado_objeto instanceof EstadoObjeto)) {
            throw new Exception("Estado de Objeto inexistente");
        }
        $this->estado_objeto->excluirObjeto();
        unset($this->estado_objeto);
    }

    public function &getUnidades() {
        return $this->unidades;
    }

    public function setUnidades(&$unidades) {
        $this->unidades = &$unidades;
    }

    public function addUnidade(Unidade &$unidade) {
        if ($this->unidades[$unidade->getCod_unidade()] instanceof Unidade) {
            throw new Exception("Unidade existente");
        }
        $unidade->setObjeto($this);
        $unidade->cadastrarObjeto();
        $this->unidades[$unidade->getCod_unidade()] = &$unidade;
    }

    public function updateUnidade($cod_unidade, $campo_id, $campo_valor) {
        if (!($this->unidades[$cod_unidade] instanceof Unidade)) {
            throw new Exception("Unidade inexistente");
        }
        $this->unidades[$cod_unidade]->alterarObjeto($campo_id, $campo_valor);
    }

    public function removeUnidade($cod_unidade) {
        if (!($this->unidades[$cod_unidade] instanceof Unidade)) {
            throw new Exception("Unidade inexistente");
        }
        $this->unidades[$cod_unidade]->excluirObjeto();
        unset($this->unidades[$cod_unidade]);
    }

    public function cadastrar() {
        if (!$this->validar()) {
            throw new Exception("Objeto existente");
        }
        $banco = BancoDeDados::getInstance();
        $link = $banco->getLink();
        $stmt = $link->prepare('insert into titulo (cod_registro, numero_serie, marca, modelo, copia, bibliografia, etiqueta, cod_classe, cod_espaco) values(?,?,?,?,?,?,?,?,?)');
        $result = $link->execute($stmt, array($this->cod_registro, $this->numero_serie, $this->marca, $this->modelo, $this->copia, $this->bibliografia, $this->etiqueta, $this->classe->getCod_classe(), $this->espaco_cultural->getCod_espaco()));
        if (DB::isError($result)) {
            $link->rollBack();
            throw new Exception("Standard Message: {$result->getMessage()}<br>Standard Code: {$result->getCode()}<br>DBMS/User Message: {$result->getUserInfo()}<br>DBMS/Debug Message: {$result->getDebugInfo()}");
        }
        $link->commit();
    }

    public function alterarCampo(&$campo_id, &$campo_valor) {
        if ($campo_id == 'numero_serie') {
            $this->numero_serie = &$campo_valor;
        } elseif ($campo_id == 'marca') {
            $this->marca = &$campo_valor;
        } elseif ($campo_id == 'modelo') {
            $this->modelo = &$campo_valor;
        } elseif ($campo_id == 'copia') {
            $this->copia = &$campo_valor;
        } elseif ($campo_id == 'bibliografia') {
            $this->bibliografia = &$campo_valor;
        } elseif ($campo_id == 'etiqueta') {
            $this->etiqueta = &$campo_valor;
        } elseif ($campo_id == 'cod_classe') {
            if (!($campo_valor instanceof Classe)) {
                throw new Exception("Classe inválida");
            }
            $this->classe = &$campo_valor;
            $campo_valor = &$this->classe->getCod_classe();
        }
        $banco = BancoDeDados::getInstance();
        $link = $banco->getLink();
        $stmt = $link->prepare('update objeto set ' . $campo_id . ' = ? where cod_interno = ?');
        $result = $link->execute($stmt, array($campo_valor, $this->cod_interno));
        if (DB::isError($result)) {
            $link->rollBack();
            throw new Exception("Standard Message: {$result->getMessage()}<br>Standard Code: {$result->getCode()}<br>DBMS/User Message: {$result->getUserInfo()}<br>DBMS/Debug Message: {$result->getDebugInfo()}");
        }
        $link->commit();
    }

    public static function listar(&$query, array &$dados) {
        $banco = BancoDeDados::getInstance();
        $result = $banco->getLink()->query("select o.cod_interno, o.cod_registro, o.nome, o.cod_espaco from objeto o " . $query, $dados);
        if (DB::isError($result)) {
            throw new Exception("Standard Message: {$result->getMessage()}<br>Standard Code: {$result->getCode()}<br>DBMS/User Message: {$result->getUserInfo()}<br>DBMS/Debug Message: {$result->getDebugInfo()}");
        }
        $resultado = array();
        while ($result->fetchInto($row)) {
            $objeto = new Objeto();
            $objeto->setCod_Interno($row['cod_interno']);
            $objeto->setCod_registro($row['cod_registro']);
            $objeto->setNome($row['nome']);
            $objeto->setEspaco_cultural(EspacoCultural::consultarPorObjeto($cod_espaco));
            $resultado[$row['cod_interno']] = &$objeto;
            unset($objeto);
        }
        return $resultado;
    }

    public static function consultar(&$cod_interno) {
        $banco = BancoDeDados::getInstance();
        $result = $banco->getLink()->query("select * from objeto where cod_interno = ?", array($cod_interno));
        if (DB::isError($result)) {
            throw new Exception("Standard Message: {$result->getMessage()}<br>Standard Code: {$result->getCode()}<br>DBMS/User Message: {$result->getUserInfo()}<br>DBMS/Debug Message: {$result->getDebugInfo()}");
        }
        if ($result->numRows() == 0) {
            throw new Exception("Objeto inexistente");
        } elseif ($result->numRows() > 1) {
            throw new Exception("Mais de um objeto com o mesmo registro na mesma localização, informar ao administrador");
        }
        $result->fetchInto($row);
        $objeto = new Objeto();
        $objeto->setCod_interno($row['cod_interno']);
        $objeto->setCod_registro($row['cod_registro']);
        $objeto->setNumero_serie($row['numserie']);
        $objeto->setMarca($row['marca']);
        $objeto->setCopia($row['copia']);
        $objeto->setBibliografia($row['bibliografia']);
        $objeto->setEtiqueta($row['etiqueta']);
        $objeto->setClasse(Classe::consultar($row['cod_classe']));
        $objeto->setMateriais(Material::listarPorObjeto($this));
        $objeto->setEmpregos(Emprego::listarPorObjeto($this));
        $objeto->setOrigem(Origem::consultar($this, $row['cod_origem']));
        $objeto->setFatos(FatoHistorico::listarPorObjeto($this));
        $objeto->setFabricantes(Fabricante::listarPorObjeto($this));
        $objeto->setPersonagens(Personagem::listarPorObjeto($this));
        $objeto->setImagens(Imagem::listar($this));
        $objeto->setEstilo(Estilo::consultar($this, $row['cod_estilo']));
        $objeto->setAssuntos(Assunto::listarPorObjeto($this));
        $objeto->setIntervencoes(Intervencao::listar($this));
        $objeto->setAutores(Autor::listarPorObjeto($this));
        $objeto->setHistoricos_movimentacao(HistoricoMovimentacao::listar($this));
        $objeto->setEstado_objeto(EstadoObjeto::consultar($this));
        $objeto->setLocalizacao(Localizacao::consultar($this));
        $objeto->setEspaco_cultural(EspacoCultural::consultarPorObjeto($this));
        $objeto->setColecao(Colecao::consultar($this, $row['cod_colecao']));
        $objeto->setTecnicas(Tecnica::listarPorObjeto($this));
        $objeto->setTitulo(Titulo::consultar($this, $row['cod_titulo']));
        $objeto->setEpoca(Epoca::consultar($this, $row['cod_epoca']));
        $objeto->setUnidades(Unidade::listarPorObjeto($this));
        $objeto->setAquisicao(Aquisicao::consultarPorObjeto($this));
        return $objeto;
    }

    public function excluir() {
        $banco = BancoDeDados::getInstance();
        $link = $banco->getLink();
        $stmt = $link->prepare('delete from objeto where cod_interno = ?');
        $result = $link->execute($stmt, array($this->cod_interno));
        if (DB::isError($result)) {
            $link->rollBack();
            throw new Exception("Standard Message: {$result->getMessage()}<br>Standard Code: {$result->getCode()}<br>DBMS/User Message: {$result->getUserInfo()}<br>DBMS/Debug Message: {$result->getDebugInfo()}");
        }
        $link->commit();
    }

    private function validar() {
        $banco = BancoDeDados::getInstance();
        $result = $banco->getLink()->query('select cod_interno from objeto, espaco where objeto.cod_espaco = espaco.cod_espaco and objeto.cod_registro = ? and espaco.cod_espaco = ?', array($this->cod_registro, $this->espaco_cultural->getCod_espaco()));
        if (DB::isError($result)) {
            throw new Exception("Standard Message: {$result->getMessage()}<br>Standard Code: {$result->getCode()}<br>DBMS/User Message: {$result->getUserInfo()}<br>DBMS/Debug Message: {$result->getDebugInfo()}");
        }
        if ($result->numRows() > 0) {
            return false;
        }
        return true;
    }

}
?>